﻿<h1>通道</h1>

<p>
通道是Go中的一种一等公民类型。它是Go的招牌特性之一。
和另一个招牌特性协程一起，这两个招牌特性使得并发编程（concurrent programming）变得十分方便和有趣，并且大大降低了并发编程的难度。
</p>

<p>
本篇文章将列出所有的和通道相关的概念、语法和规则。为了更好地理解通道，本文也对通道的可能的内部实现略加介绍。
</p>

<p>
本篇文章中的信息量对于Go初学者来说可能有些密集。本文的某些段落可能需要反复阅读几遍才能有效吸收、消化和理解。
</p>

<h3>并发编程和并发同步（concurrency synchronization）</h3>

<div>
<p>
现代CPU一般含有多个核，并且一个核可能支持多线程。换句话说，现代CPU可以同时执行多条指令流水线。
为了将CPU的能力发挥到极致，我们常常需要使我们的程序支持并发计算。
</p>

<p>
并发计算是指若干计算可能在某些时间片段内同时运行的情形。
下面这两张图描绘了两种并发计算的场景。在此图中，A和B表示两个计算。
在第一种情形中，两个计算只在某些时间片段同时运行。
第二种情形称为并行计算。在并行计算中，多个计算在任何时间点都在同时运行。并行计算是一种特殊的并发计算。
<div class="text-center">
<img src="res/concurrent-vs-parallel.png" alt="并发和并行"></img>
</div>
</p>

<p>
并发计算可能发生在同一个程序中、同一台电脑上、或者同一个网络中。
在《Go语言101》中，我们只谈及发生在同一个程序中的并发计算。
前面已经介绍过的<a href="control-flows-more.html">协程</a>是Go中创建计算的唯一途径。
</p>

不同的并发计算可能共享一些资源，其中共享内存资源最为常见。
在一个并发程序中，常常会发生下面的情形：
<ul>
<li>
	在一个计算向一段内存写数据的时候，另一个计算从此内存段读数据，结果导致读出的数据的完整性得不到保证。
</li>
<li>
	在一个计算向一段内存写数据的时候，另一个计算也向此段内存写数据，结果导致被写入的数据的完整性得不到保证。
</li>
</ul>

<p>
这些情形被称为数据竞争（data race）。并发编程的一大任务就是要调度不同计算，控制它们对资源的访问时段，以使数据竞争的情况不会发生。
此任务常称为并发同步（或者数据同步）。Go支持几种并发同步技术，本文将只介绍它们中的一个：通道。
</p>

并发编程中的其它任务包括：
<ul>
<li>
	决定需要开启多少计算；
</li>
<li>
	决定何时开启、阻塞、解除阻塞和结束哪些计算；
</li>
<li>
	决定如何在不同的计算中分担工作负载。
</li>
</ul>

<p>
Go中大多数的操作都是未同步的。换句话说，它们都不是并发安全的。
这些操作包括赋值、传参、和各种容器值操作等。
Go中只有少数操作是并发安全的，本文下面将介绍其中的几个。
</p>

<p>
在Go中，每个计算都是一个协程。所以以后我们也常常用协程来表示计算。
</p>

</div>

<h3>通道（channel）介绍</h3>

<p>
Go语言设计团队的首任负责人<i>Rob Pike</i>对并发编程的一个建议是<b>不要让计算通过共享内存来通讯，而应该让它们通过通讯来共享内存</b>。
通道机制就是这种哲学的一个设计结果。
</p>

<p>
通过共享内存来通讯和通过通讯来共享内存是并发编程中的两种编程风格。
当通过共享内存来通讯的时候，我们需要一些传统的并发同步技术（比如互斥锁）来避免数据竞争。
</p>

<p>
Go提供了一种独特的并发同步技术来实现通过通讯来共享内存。此技术即为通道。
我们可以把一个通道看作是在一个程序内部的一个先进先出（FIFO：first in first out）数据队列。
一些协程可以向此通道发送数据，另外一些协程可以从此通道接收数据。
</p>

<p>
随着一个数据值的传递（发送和接收），一些数据值的所有权从一个协程转移到了另一个协程。
当一个协程发送一个值到一个通道，我们可以认为此协程释放了一些值的所有权。
当一个协程从一个通道接收到一个值，我们可以认为此协程获取了一些值的所有权。
</p>

<p>
当然，在通过通道传递数据的时候，也可能没有任何所有权发生转移。
</p>

<p>
所有权发生转移的值常常被传递的值所引用着，但有时候也不并非如此。
在Go中，和Rust语言不同，数据所有权的转移并非体现在语法上，而是体现在逻辑上。
Go通道可以帮助程序员轻松地避免数据竞争，但不会绝对防止程序员犯错而写出糟烂的并发代码。
</p>

<p>
尽管Go也支持几种传统的数据同步技术，但是只有通道为一等公民。
通道是Go中的一种类型，所以我们可以无需引进任何代码包就可以使用通道。
几种传统的数据同步技术提供在<code>sync</code>和<code>sync/atomic</code>标准库包中。
</p>

<p>
实事求是地说，每种并发同步技术都有它们各自的最佳应用场景，但是通道的<a href="channel-use-cases.html">应用范围更广</a>。
使用通道来做同步常常可以使得代码看上去更整洁和易于理解。
</p>

<p>
通道的一个问题是通道的编程体验常常很有趣以至于程序员们经常在并非是通道的最佳应用场景中仍坚持使用通道。
</p>

<h3>通道类型和值</h3>

<div>
<p>
和数组、切片以及映射类型一样，每个通道类型也有一个元素类型。
一个通道只能传送它的（通道类型的）元素类型的值。
</p>

通道可以是双向的，也可以是单向的。
<ul>
<li>
	字面形式<code>chan T</code>表示一个元素类型为<code>T</code>的双向通道类型。
	编译器允许从此类型的值中接收和向此类型的值中发送数据。
</li>
<li>
	字面形式<code>chan&lt;- T</code>表示一个元素类型为<code>T</code>的单向发送通道类型。
	编译器不允许从此类型的值中接收数据。
</li>
<li>
	字面形式<code>&lt;-chan T</code>表示一个元素类型为<code>T</code>的单向接收通道类型。
	编译器不允许向此类型的值中发送数据。
</li>
</ul>

<p>
双向通道<code>chan T</code>的值可以被隐式转换为单向通道类型<code>chan&lt;- T</code>和<code>&lt;-chan T</code>，但反之不行（即使显式也不行）。
类型<code>chan&lt;- T</code>和<code>&lt;-chan T</code>的值也不能相互转换。
</p>

<p>
每个通道值有一个容量属性。此属性的意义将在下一节中得到解释。
一个容量为0的通道值称为一个非缓冲通道（unbuffered channel），一个容量不为0的通道值称为一个缓冲通道（buffered channel）。
</p>

<p>
通道类型的零值也使用预声明的<code>nil</code>来表示。
一个非零通道值必须通过内置的<code>make</code>函数来创建。
比如<code>make(chan int, 10)</code>将创建一个元素类型为<code>int</code>的通道值。
第二个参数指定了欲创建的通道的容量。此第二个实参是可选的，它的默认值为<code>0</code>。
</p>

</div>

<a class="anchor" id="assign-and-compare"></a>
<h3>通道值的比较</h3>

<p>
所有通道类型均为可比较类型。
</p>

<p>
从<a href="value-part.html">值部</a>一文，我们了解到一个通道值可能含有底层部分。
当一个通道值被赋给另一个通道值后，这两个通道值将共享相同的底层部分。
换句话说，这两个通道引用着同一个底层的内部通道对象。
比较这两个通道的结果为<code>true</code>。
</p>

<a class="anchor" id="operations"></a>
<h3>通道操作</h3>

<div>
<p>
Go中有五种通道相关的操作。假设一个通道（值）为<code>ch</code>，下面列出了这五种操作的语法或者函数调用。
</p>
<ol>
<li>
	调用内置函数<code>close</code>来关闭一个通道：
<pre class="disable-line-numbers111"><code class="language-go">close(ch)
</code></pre>
	<p>
	传给<code>close</code>函数调用的实参必须为一个通道值，并且此通道值不能为单向接收的。
	</p>
</li>
<li>
	使用下面的语法向通道<code>ch</code>发送一个值<code>v</code>：
<pre class="disable-line-numbers111"><code class="language-go">ch &lt;- v
</code></pre>
	<p>
	<code>v</code>必须能够赋值给通道<code>ch</code>的元素类型。
	<code>ch</code>不能为单向接收通道。
	<code>&lt;-</code>称为数据发送操作符。
	</p>
</li>
<li>
	使用下面的语法从通道<code>ch</code>接收一个值：
<pre class="disable-line-numbers111"><code class="language-go">&lt;-ch
</code></pre>
	如果一个通道操作不永久阻塞，它总会返回至少一个值，此值的类型为通道<code>ch</code>的元素类型。
	<code>ch</code>不能为单向发送通道。
	<code>&lt;-</code>称为数据接收操作符，是的它和数据发送操作符的表示形式是一样的。

	<p>
	</p>

	在大多数场合下，一个数据接收操作可以被认为是一个单值表达式。
	但是，当一个数据接收操作被用做一个赋值语句中的唯一的源值的时候，它可以返回第二个可选的类型不确定的布尔值返回值从而成为一个多值表达式。
	此类型不确定的布尔值表示第一个接收到的值是否是在通道被关闭前发送的。
	（从后面的章节，我们将得知我们可以从一个已关闭的通道中接收到无穷个值。）

	<p>
	</p>

	数据接收操作在赋值中被用做源值的例子：
<pre class="disable-line-numbers111"><code class="language-go">v = &lt;-ch
v, sentBeforeClosed = &lt;-ch
</code></pre>
</li>
<li>
	查询一个通道的容量：
<pre class="disable-line-numbers111"><code class="language-go">cap(ch)
</code></pre>
	<p>
	其中<code>cap</code>是一个已经在<a href="container.html#cap-len">容器类型</a>一文中介绍过的内置函数。
	<code>cap</code>的返回值的类型为内置类型<code>int</code>。
	</p>
</li>
<li>
	查询一个通道的长度：
<pre class="disable-line-numbers111"><code class="language-go">len(ch)
</code></pre>
	<p>
	其中<code>len</code>是一个已经在<a href="container.html#cap-len">容器类型</a>一文中介绍过的内置函数。
	<code>len</code>的返回值的类型也为内置类型<code>int</code>。
	一个通道的长度是指当前有多少个已被发送到此通道但还未被接收出去的元素值。
	</p>
</li>
</ol>

<p>
除了并发地关闭一个通道和向此通道发送数据这种情形，上面这些所有列出的操作都已经同步过了，因此它们可以在并发协程中安全运行而无需其它同步操作。
我们在编程中应该避免并发地关闭一个通道和向此通道发送数据这种情形，
因为这种情形属于不良设计（原因将在下面解释）。
</p>

<!--
https://github.com/golang/go/issues/30372
https://github.com/golang/go/issues/27769
-->

<p>
注意：通道的赋值和其它类型值的赋值一样，是未同步的。
同样，将刚从一个通道接收出来的值赋给另一个值也是未同步的。
</p>

<p>
如果被查询的通道为一个nil零值通道，则<code>cap</code>和<code>len</code>函数调用都返回<code>0</code>。
这两个操作是如此简单，所以后面将不再对它们进行详解。
事实上，这两个操作在实践中很少使用。
</p>

<p>
通道的发送、接收和关闭操作将在下一节得到详细解释。
</p>

</div>

<a class="anchor" id="channel-operation-explanations"></a>
<h3>通道操作详解</h3>

<div>
为了让解释简单清楚，在本文后续部分，通道将被归为三类：
<ol>
<li>
	零值（nil）通道；
</li>
<li>
	非零值但已关闭的通道；
</li>
<li>
	非零值并且尚未关闭的通道。
</li>
</ol>

<p>
下表简单地描述了三种通道操作施加到三类通道的结果。
</p>

<table border="1" class="table table-bordered text-center" style="width: auto !important;">
<thead>
	<tr class="active">
	<th class="text-center" valign="bottom" align="center">操作</th>
	<th class="text-center" valign="bottom" align="center">一个零值nil通道</th>
	<th class="text-center" valign="bottom" align="center">一个非零值但已关闭的通道</th>
	<th class="text-center" valign="bottom" align="center">一个非零值且尚未关闭的通道</th>
	</tr>
</thead>
<tbody>
	<tr>
	<th scope="row" class="text-center">关闭</th>
	<td style="vertical-align: middle;" valign="middle" align="center">产生恐慌</td>
	<td style="vertical-align: middle;" valign="middle" align="center">产生恐慌</td>
	<td style="vertical-align: middle;" valign="middle" align="center">成功关闭<sup>(C)</sup></td>
	</tr>
	<tr>
	<th scope="row" class="text-center">发送数据</th>
	<td style="vertical-align: middle;" valign="middle" align="center">永久阻塞</td>
	<td style="vertical-align: middle;" valign="middle" align="center">产生恐慌</td>
	<td style="vertical-align: middle;" valign="middle" align="center">阻塞或者成功发送<sup>(B)</sup></td>
	</tr>
	<tr>
	<th scope="row" class="text-center">接收数据</th>
	<td style="vertical-align: middle;" valign="middle" align="center">永久阻塞</td>
	<td style="vertical-align: middle;" valign="middle" align="center">永不阻塞<sup>(D)</sup></td>
	<td style="vertical-align: middle;" valign="middle" align="center">阻塞或者成功接收<sup>(A)</sup></td>
	</tr>
</tbody>
</table>

对于上表中的五种未打上标的情形，规则很简单：
<ul>
<li>
	关闭一个nil通道或者一个已经关闭的通道将产生一个恐慌。
</li>
<li>
	向一个已关闭的通道发送数据也将导致一个恐慌。
</li>
<li>
	向一个nil通道发送数据或者从一个nil通道接收数据将使当前协程永久阻塞。
</li>
</ul>

<p>
下面将详细解释其它四种被打了上标（A/B/C/D）的情形。
</p>

<p>
为了更好地理解通道和为了后续讲解方便，先了解一下通道类型的大致内部实现是很有帮助的。
</p>

我们可以认为一个通道内部维护了三个队列（均可被视为先进先出队列）：
<ol>
<li>
	接收数据协程队列。此队列是一个没有长度限制的链表。
	此队列中的协程均处于阻塞状态，它们正等待着从此通道接收数据。
	<!-- not true
	The addresses of the values which are prepared to store the received
	values are also stored in the queue along with each goroutine.
	-->
</li>
<li>
	发送数据协程队列。此队列也是一个没有长度限制的链表。
	此队列中的协程亦均处于阻塞状态，它们正等待着向此通道发送数据。
	此队列中的每个协程将要发送的值（或者此值的指针，取决于具体编译器实现）和此协程一起存储在此队列中。
</li>
<li>
	数据缓冲队列。这是一个循环队列，它的长度为此通道的容量。此队列中存放的值的类型都为此通道的元素类型。
	如果此队列中当前存放的值的个数已经达到此通道的容量，则我们说此通道已经处于满槽状态。
	如果此队列中当前存放的值的个数为零，则我们说此通道处于空槽状态。
	对于一个非缓冲通道（容量为零），它总是同时处于满槽状态和空槽状态。
</li>
</ol>

<p>
每个通道内部维护着一个互斥锁用来在各种通道操作中防止数据竞争。
</p>


<u><b>通道操作情形A</b>：
当一个协程<code>Gr</code>尝试从一个非零且尚未关闭的通道接收数据的时候</u>，此协程<code>Gr</code>将首先尝试获取此通道的锁，成功之后将执行下列步骤，直到其中一个步骤的条件得到满足。
<ol>
<li>
	如果此通道的缓冲队列不为空（这种情况下，接收数据协程队列必为空），此协程<code>Gr</code>将从缓冲队列取出接收一个值。
	如果发送数据协程队列不为空，一个发送协程将从此队列中弹出，此协程欲发送的值将被推入缓冲队列。	此发送协程将恢复至运行状态。
	接收数据协程<code>Gr</code>继续运行，不会阻塞。对于这种情况，此数据接收操作为一个<b>非阻塞操作</b>。
</li>
<li>
	否则（即此通道的缓冲队列为空），如果发送数据协程队列不为空（这种情况下，此通道必为一个非缓冲通道），
	一个发送数据协程将从此队列中弹出，此协程欲发送的值将被接收数据协程<code>Gr</code>接收。此发送协程将恢复至运行状态。
	接收数据协程<code>Gr</code>继续运行，不会阻塞。对于这种情况，此数据接收操作为一个<b>非阻塞操作</b>。
</li>
<li>
	对于剩下的情况（即此通道的缓冲队列和发送数据协程队列均为空），此接收数据协程<code>Gr</code>将被推入接收数据协程队列，并进入阻塞状态。
	它以后可能会被另一个发送数据协程唤醒而恢复运行。
	对于这种情况，此数据接收操作为一个<b>阻塞操作</b>。
</li>
</ol>

<u><b>通道操作情形B</b>：
当一个协程<code>Gs</code>尝试向一个非零且尚未关闭的通道发送数据的时候</u>，此协程<code>Gs</code>将首先尝试获取此通道的锁，成功之后将执行下列步骤，直到其中一个步骤的条件得到满足。
<ol>
<li>
	如果此通道的接收数据协程队列不为空（这种情况下，缓冲队列必为空），
	一个接收数据协程将从此队列中弹出，此协程将接收到发送协程<code>Gs</code>发送的值。此接收协程将恢复至运行状态。
	发送数据协程<code>Gs</code>继续运行，不会阻塞。对于这种情况，此数据发送操作为一个<b>非阻塞操作</b>。
</li>
<li>
	否则（接收数据协程队列为空），如果缓冲队列未满（这种情况下，发送数据协程队列必为空），
	发送协程欲<code>Gs</code>发送的值将被推入缓冲队列，发送数据协程<code>Gs</code>继续运行，不会阻塞。
	对于这种情况，此数据发送操作为一个<b>非阻塞操作</b>。
</li>
<li>
	对于剩下的情况（接收数据协程队列为空，并且缓冲队列已满），此发送协程<code>Gs</code>将被推入发送数据协程队列，并进入阻塞状态。
	它以后可能会被另一个接收数据协程唤醒而恢复运行。
	对于这种情况，此数据发送操作为一个<b>阻塞操作</b>。
</li>
</ol>

<p>
上面已经提到过，一旦一个非零通道被关闭，继续向此通道发送数据将产生一个恐慌。
注意，向关闭的通道发送数据属于一个<b>非阻塞操作</b>。
</p>

<u><b>通道操作情形C</b>：
当一个协程成功获取到一个非零且尚未关闭的通道的锁并且准备关闭此通道时</u>，下面两步将依次执行：
<ol>
<li>
	如果此通道的接收数据协程队列不为空（这种情况下，缓冲队列必为空），此队列中的所有协程将被依个弹出，并且每个协程将接收到此通道的元素类型的一个零值，然后恢复至运行状态。
</li>
<li>
	如果此通道的发送数据协程队列不为空，此队列中的所有协程将被依个弹出，并且每个协程中都将产生一个恐慌（因为向已关闭的通道发送数据）。
	这就是我们在上面说并发地关闭一个通道和向此通道发送数据这种情形属于不良设计的原因。
	事实上，并发地关闭一个通道和向此通道发送数据将产生数据竞争。
</li>
</li>
</ol>

<p>
注意：当一个缓冲队列不为空的通道被关闭之后，它的缓冲队列不会被清空，其中的数据仍然可以被后续的数据接收操作所接收到。详见下面的对情形D的解释。
</p>

<p>
<u><b>通道操作情形D</b>：
一个非零通道被关闭之后，此通道上的后续数据接收操作将永不会阻塞</u>。
此通道的缓冲队列中存储数据仍然可以被接收出来。
伴随着这些接收出来的缓冲数据的第二个可选返回（类型不确定布尔）值仍然是<code>true</code>。
一旦此缓冲队列变为空，后续的数据接收操作将永不阻塞并且总会返回此通道的元素类型的零值和值为<code>false</code>的第二个可选返回结果。
上面已经提到了，一个接收操作的第二个可选返回（类型不确定布尔）结果表示一个接收到的值是否是在此通道被关闭之前发送的。
如果此返回值为<code>false</code>，则第一个返回值必然是一个此通道的元素类型的零值。
</p>

<p>
知道哪些通道操作是阻塞的和哪些是非阻塞的对正确理解后面将要介绍的<code>select</code>流程控制机制非常重要。
</p>

<p>
如果一个协程被从一个通道的某个队列中（不论发送数据协程队列还是接收数据协程队列）弹出，并且此协程是在一个<a href="#select"><code>select</code>控制流程</a>中推入到此队列的，那么此协程将在下面将要讲解的<a href="#select-implementation"><code>select</code>控制流程的执行步骤</a>中的第<i>9</i>步中恢复至运行状态，并且同时它会被从相应的<code>select</code>控制流程中的相关的若干通道的协程队列中移除掉。
</p>

根据上面的解释，我们可以得出如下的关于一个通道的内部的三个队列的各种事实：
<ul>
<li>
	如果一个通道已经关闭了，则它的发送数据协程队列和接收数据协程队列肯定都为空，但是它的缓冲队列可能不为空。
</li>
<li>
	在任何时刻，如果缓冲队列不为空，则接收数据协程队列必为空。
</li>
<li>
	在任何时刻，如果缓冲队列未满，则发送数据协程队列必为空。
</li>
<li>
	如果一个通道是缓冲的，则在任何时刻，它的发送数据协程队列和接收数据协程队列之一必为空。
</li>
<li>
	如果一个通道是非缓冲的，则在任何时刻，一般说来，它的发送数据协程队列和接收数据协程队列之一必为空，
	但是有一个例外：一个协程可能在一个<a href="#select"><code>select</code>流程控制</a>中同时被推入到此通道的发送数据协程队列和接收数据协程队列中。
</li>
</ul>
</div>

<h3>一些通道的使用例子</h3>

<div>
<p>
来看一些通道的使用例子来加深一下对上一节中的解释的理解。
</p>

一个简单的通过一个非缓冲通道实现的请求/响应的例子：
<pre class="line-numbers"><code class="language-go">package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int) // 一个非缓冲通道
	go func(ch chan<- int, x int) {
		time.Sleep(time.Second)
		// <-ch    // 此操作编译不通过
		ch <- x*x  // 阻塞在此，直到发送的值被接收
	}(c, 3)
	done := make(chan struct{})
	go func(ch <-chan int) {
		n := <-ch      // 阻塞在此，直到有值发送到c
		fmt.Println(n) // 9
		// ch <- 123   // 此操作编译不通过
		time.Sleep(time.Second)
		done <- struct{}{}
	}(c)
	<-done // 阻塞在此，直到有值发送到done
	fmt.Println("bye")
}
</code></pre>

<p>
</p>

输出结果：
<pre class="output"><code>9
bye
</code></pre>

<p>
</p>

下面的例子使用了一个缓冲通道。此例子程序并非是一个并发程序，它只是为了展示缓冲通道的使用。

<pre class="line-numbers"><code class="language-go">package main

import "fmt"

func main() {
	c := make(chan int, 2) // 一个容量为2的缓冲通道
	c <- 3
	c <- 5
	close(c)
	fmt.Println(len(c), cap(c)) // 2 2
	x, ok := <-c
	fmt.Println(x, ok) // 3 true
	fmt.Println(len(c), cap(c)) // 1 2
	x, ok = <-c
	fmt.Println(x, ok) // 5 true
	fmt.Println(len(c), cap(c)) // 0 2
	x, ok = <-c
	fmt.Println(x, ok) // 0 false
	x, ok = <-c
	fmt.Println(x, ok) // 0 false
	fmt.Println(len(c), cap(c)) // 0 2
	close(c) // 此行将产生一个恐慌
	c <- 7   // 如果上一行不存在，此行也将产生一个恐慌。
}
</code></pre>

<p>
</p>

一场永不休场的足球比赛：

<pre class="line-numbers"><code class="language-go">package main

import (
	"fmt"
	"time"
)

func main() {
	var ball = make(chan string)
	kickBall := func(playerName string) {
		for {
			fmt.Print(<-ball, "传球", "\n")
			time.Sleep(time.Second)
			ball <- playerName
		}
	}
	go kickBall("张三")
	go kickBall("李四")
	go kickBall("王二麻子")
	go kickBall("刘大")
	ball <- "裁判"   // 开球
	var c chan bool // 一个零值nil通道
	<-c             // 永久阻塞在此
}
</code></pre>

<p>
</p>

<p>
请阅读<a href="channel-use-cases.html">通道用例大全</a>来查看更多通道的使用例子。
</p>

</div>

<h3>通道的元素值的传递都是复制过程</h3>

<p>
在一个值被从一个协程传递到另一个协程的过程中，此值将被复制至少一次。
如果此传递值曾经在某个通道的缓冲队列中停留过，则它在此传递过程中将被复制两次。
一次复制发生在从发送协程向缓冲队列推入此值的时候，另一个复制发生在接收协程从缓冲队列取出此值的时候。
和赋值以及函数调用传参一样，当一个值被传递时，<a href="value-part.html#about-value-copy">只有它的直接部分被复制</a>。
</p>

<p>
对于官方标准编译器，最大支持的通道的元素类型的尺寸为<code>65535</code>。
但是，一般说来，为了在数据传递过程中避免过大的复制成本，我们不应该使用尺寸很大的通道元素类型。
如果欲传送的值的尺寸较大，应该改用指针类型做为通道的元素类型。
</p>

<h3>关于通道和协程的垃圾回收</h3>

<p>
注意，一个通道被其发送数据协程队列和接收数据协程队列中的所有协程引用着。因此，如果一个通道的这两个队列只要有一个不为空，则此通道肯定不会被垃圾回收。
另一方面，如果一个协程处于一个通道的某个协程队列之中，则此协程也肯定不会被垃圾回收，即使此通道仅被此协程所引用。
事实上，一个协程只有在退出后才能被垃圾回收。
</p>

<h3>数据接收和发送操作都属于简单语句</h3>

<div>
<p>
数据接收和发送操作都属于<a href="expressions-and-statements.html#simple-statements">简单语句</a>。
另外一个数据接收操作总是可以被用做一个单值表达式。
简单语句和表达式可以被用在<a href="control-flows.html">一些控制流程</a>的某些部分。
</p>

在下面这个例子中，数据接收和发送操作被用在两个<code>for</code>循环的初始化和步尾语句。

<pre class="line-numbers"><code class="language-go">package main

import (
	"fmt"
	"time"
)

func main() {
	fibonacci := func() chan uint64 {
		c := make(chan uint64)
		go func() {
			var x, y uint64 = 0, 1
			for ; y < (1 << 63); c <- y { // 步尾语句
				x, y = y, x+y
			}
			close(c)
		}()
		return c
	}
	c := fibonacci()
	for x, ok := <-c; ok; x, ok = <-c { // 初始化和步尾语句
		time.Sleep(time.Second)
		fmt.Println(x)
	}
}
</code></pre>

<p>
</p>

</div>

<a class="anchor" id="range"></a>
<h3><code>for-range</code>应用于通道</h3>

<div>
<code>for-range</code>循环控制流程也适用于通道。
此循环将不断地尝试从一个通道接收数据，直到此通道关闭并且它的缓冲队列中为空为止。
和应用于数组/切片/映射的<code>for-range</code>语法不同，应用于通道的<code>for-range</code>语法中最多只能出现一个循环变量，此循环变量用来存储接收到的值。

<pre class="line-numbers"><code class="language-go">for v = range aChannel {
	// 使用v
}
</code></pre>

等价于

<pre class="line-numbers"><code class="language-go">for {
	v, ok = <-aChannel
	if !ok {
		break
	}
	// 使用v
}
</code></pre>

<p>
当然，这里的通道<code>aChannel</code>一定不能为一个单向发送通道。
如果它是一个nil零值，则此<code>for-range</code>循环将使当前协程永久阻塞。
</p>

上一节中的例子中的最后一个<code>for</code>循环可以改写为下面这样：

<pre class="line-numbers"><code class="language-go">	for x := range c {
		time.Sleep(time.Second)
		fmt.Println(x)
	}
</code></pre>

<p>
</p>
</div>

<a class="anchor" id="select"></a>
<h3><code>select-case</code>分支流程控制代码块</h3>

<div>
Go中有一个专门为通道设计的<code>select-case</code>分支流程控制语法。
此语法和<code>switch-case</code>分支流程控制语法很相似。
比如，<code>select-case</code>流程控制代码块中也可以有若干<code>case</code>分支和最多一个<code>default</code>分支。
但是，这两种流程控制也有很多不同点。在一个<code>select-case</code>流程控制中，
<ul>
<li>
	<code>select</code>关键字和<code>{</code>之间不允许存在任何表达式和语句。
</li>
<li>
	<code>fallthrough</code>语句不能被使用.
</li>
<li>
	每个<code>case</code>关键字后必须跟随一个通道接收数据操作或者一个通道发送数据操作。
	通道接收数据操作可以做为源值出现在一条简单赋值语句中。
	以后，一个<code>case</code>关键字后跟随的通道操作将被称为一个<code>case</code>操作。
</li>
<li>
	所有的非阻塞<code>case</code>操作中将有一个被随机选择执行（而不是按照从上到下的顺序），然后执行此操作对应的<code>case</code>分支代码块。
</li>
<li>
	在所有的<code>case</code>操作均为阻塞的情况下，如果<code>default</code>分支存在，则<code>default</code>分支代码块将得到执行；
	否则，当前协程将被推入所有阻塞操作中相关的通道的发送数据协程队列或者接收数据协程队列中，并进入阻塞状态。
</li>
</ul>

<p>
按照上述规则，一个不含任何分支的<code>select-case</code>代码块<code>select{}</code>将使当前协程处于永久阻塞状态。
</p>

在下面这个例子中，<code>default</code>分支将铁定得到执行，因为另两个<code>case</code>分支后的操作均为阻塞的。
<pre class="line-numbers"><code class="language-go">package main

import "fmt"

func main() {
	var c chan struct{} // nil
	select {
	case <-c:             // 阻塞操作
	case c <- struct{}{}: // 阻塞操作
	default:
		fmt.Println("Go here.")
	}
}
</code></pre>

<p>
</p>

下面这个例子中实现了尝试发送（try-send）和尝试接收（try-receive）。
它们都是用含有一个<code>case</code>分支和一个<code>default</code>分支的<code>select-case</code>代码块来实现的。

<pre class="line-numbers"><code class="language-go">package main

import "fmt"

func main() {
	c := make(chan string, 2)
	trySend := func(v string) {
		select {
		case c <- v:
		default: // 如果c的缓冲已满，则执行默认分支。
		}
	}
	tryReceive := func() string {
		select {
		case v := <-c: return v
		default: return "-" // 如果c的缓冲为空，则执行默认分支。
		}
	}
	trySend("Hello!") // 发送成功
	trySend("Hi!")    // 发送成功
	trySend("Bye!")   // 发送失败，但不会阻塞。
	// 下面这两行将接收成功。
	fmt.Println(tryReceive()) // Hello!
	fmt.Println(tryReceive()) // Hi!
	// 下面这行将接收失败。
	fmt.Println(tryReceive()) // -
}
</code></pre>

<p>
</p>

下面这个程序有50%的几率会因为恐慌而崩溃。
此程序中<code>select-case</code>代码块中的两个<code>case</code>操作均不阻塞，所以随机一个将被执行。
如果第一个<code>case</code>操作（向已关闭的通道发送数据）被执行，则一个恐慌将产生。

<pre class="line-numbers"><code class="language-go">package main

func main() {
	c := make(chan struct{})
	close(c)
	select {
	case c <- struct{}{}: // 若此分支被选中，则产生一个恐慌
	case <-c:
	}
}
</code></pre>


</div>

<a class="anchor" id="select-implementation"></a>
<h3><code>select-case</code>流程控制的实现机理</h3>

<div>
<p>
<code>select-case</code>流程控制是Go中的一个重要和独特的特性。
下面列出了官方标准运行时中<code>select-case</code>流程控制的<a href="https://github.com/golang/go/blob/master/src/runtime/select.go">实现步骤</a>。
</p>

<!--
If the step ids change, please also update the above reference ones.
-->

<ol>
<li>
	将所有<code>case</code>操作中涉及到的通道表达式和发送值表达式按照从上到下，从左到右的顺序一一估值。
	在赋值语句中做为源值的数据接收操作对应的目标值在此时刻不需要被估值。
</li>
<li>
	将所有分支的随机排序。<code>default</code>分支总是排在最后。
	所有<code>case</code>操作中相关的通道可能会有重复的。
</li>
<li>
	为了防止在下一步中造成死锁，对所有<code>case</code>操作中相关的通道进行排序。
	排序依据并不重要，可以按照它们的地址顺序进行排序。
	排序结果中前<code>N</code>个通道不存在重复的情况。
	<code>N</code>为所有<code>case</code>操作中不重复的通道的数量。
	下面，<b><i>通道锁顺序</i></b>是针对此排序结果中的前<code>N</code>个通道来说的，<b><i>通道锁逆序</i></b>是指此顺序的逆序。
</li>
<li>
	按照上一步中的生成通道锁顺序获取所有相关的通道的锁。
</li>
<li>
	按照第<i>2</i>步中生成的分支顺序检查相应分支：
	<ol>
	<li>
		如果这是一个<code>case</code>分支并且相应的通道操作是一个向关闭了的通道发送数据操作，则按照通道锁逆序解锁所有的通道并在当前协程中产生一个恐慌。
		跳到第<i>12</i>步。
	</li>
	<li>
		如果这是一个<code>case</code>分支并且相应的通道操作是非阻塞的，则按照通道锁逆序解锁所有的通道并执行相应的<code>case</code>分支代码块。
		（此相应的通道操作可能会唤醒另一个处于阻塞状态的协程。）
		跳到第<i>12</i>步。
	</li>
	<li>
		如果这是<code>default</code>分支，则按照通道锁逆序解锁所有的通道并执行此<code>default</code>分支代码块。
		跳到第<i>12</i>步。
	</li>
	</ol>
	（到这里，<code>default</code>分支肯定是不存在的，并且所有的<code>case</code>操作均为阻塞的。）
</li>
<li>
	将当前协程（和对应<code>case</code>分支信息）推入到每个<code>case</code>操作中对应的通道的发送数据协程队列或接收数据协程队列中。
	当前协程可能会被多次推入到同一个通道的这两个队列中，因为多个<code>case</code>操作中对应的通道可能为同一个。
</li>
<li>
	使当前协程进入阻塞状态并则按照通道锁逆序解锁所有的通道。
</li>
<li>
	...，当前协程处于阻塞状态，等待其它协程通过通道操作唤醒当前协程，...
</li>
<li>
	当前协程被另一个协程中的一个通道操作唤醒。
	此唤醒通道操作可能是一个通道关闭操作，也可能是一个数据发送/接收操作。
	如果它是一个数据发送/接收操作，则（当前正被解释的<code>select-case</code>流程中）肯定有一个相应<code>case</code>操作与之配合传递数据。
	在此配合过程中，当前协程将从相应<code>case</code>操作相关的通道的接收/发送数据协程队列中弹出。
</li>
<li>
	按照第<i>3</i>步中的生成的通道锁顺序获取所有相关的通道的锁。
</li>
<li>
	将当前协程从各个<code>case</code>操作中对应的通道的发送数据协程队列或接收数据协程队列中（可能以非弹出的方式）移除。
	<ol>
	<li>
		如果当前协程时被一个通道关闭操作所唤醒，则跳到第<i>5</i>步。
	</li>
	<li>
		如果当前协程时被一个数据发送/接收操作所唤醒，则相应的<code>case</code>分支已经在第<i>9</i>步中知晓。
		按照通道锁逆序解锁所有的通道并执行此<code>case</code>分支代码块。
	</li>
	</ol>
</li>
<li>
	完毕。
</li>
</ol>

从此实现中，我们得知
<ul>
<li>
	一个协程可能同时多次处于同一个通道的发送数据协程队列或接收数据协程队列中。
</li>
<li>
	当一个协程被阻塞在一个<code>select-case</code>流程控制中并在以后被唤醒时，它可能会从多个通道的发送数据协程队列和接收数据协程队列中被移除。
</li>
</ul>

<p>
</p>

</div>

<h3>更多</h3>

<p>
我们可以在<a href="channel-use-cases.html">通道用例大全</a>一文中找到更多通道的使用例子。
</p>

<p>
尽管通道可以帮助我们<a href="channel-closing.html">轻松地写出正确的并发代码</a>，和其它并发同步技术一样，通道并不会阻止我们<a href="concurrent-common-mistakes.html">写出不正确的并发代码</a>。
</p>

<p>
通道并非在任何场合总是最佳的并发同步方案，请阅读<a href="concurrent-synchronization-more.html">其它并发同步技术</a>和<a href="concurrent-atomic-operation.html">原子操作</a>来了解Go中支持的更多的并发同步技术。
</p>


